#include <userint.h>
#include "grap.h" 
#define SIZE 9
#define nr 'n'
#define bl 'b'
#define ab ' '
#define X  'x'
#define tmp 'X'


/*--------------------------------------------------------------------------------------------------------------------------------------------*/
														/*PROTOTYPE DES FONCTIONS*/

void bl_return_pion(int,int,int);		   //fonction principale de retournement de pion pour le cas du Joueur Blanc
int  bl_return_ht_gch(int ,int,int);	   // cas de la case au-dessus de la case clicker
int  bl_return_ht_ct(int ,int,int);
int  bl_return_ht_drt(int ,int,int);
int  bl_return_ml_gch(int ,int,int);
int  bl_return_ml_drt(int ,int,int);
int  bl_return_bs_gch(int ,int,int);
int  bl_return_bs_ct(int ,int,int);
int  bl_return_bs_drt(int ,int,int);

/*--------------------------------------------------------------------------------------------------------------------------------------------*/
													   /*VARIABLES GENERALE*/
int tab[SIZE][SIZE];
/*--------------------------------------------------------------------------------------------------------------------------------------------*/
														/*FONCTION PRINCIPALE DE RETOURNEMENT DES PIONS B*/

void bl_return_pion(int  caract,int ligne,int colonne)
{
 int i=ligne; //compteur de boucle		
 int j=colonne;
 
 
 //cherche les pions a retourner
 if(i>1 && j>1)
 tab[i][j] = bl_return_ht_gch(tab[i-1][j-1],i,j);	 //fonction de la case haut gauche 
 
 if(i>1)
 tab[i][j] = bl_return_ht_ct(tab[i-1][j],i,j);	  // fonction de la case haut centre 
 
 if(i>1 && j<SIZE-1)
 tab[i][j] = bl_return_ht_drt(tab[i-1][j+1],i,j); // fonction de la case haut droite
 
 if(j>1)
 tab[i][j] = bl_return_ml_gch(tab[i][j-1],i,j);  // fonction de la case milieu gauche 
 
 if(j<SIZE-1)
 tab[i][j] = bl_return_ml_drt(tab[i][j+1],i,j);  // fonction de la case milieu droite
 
 if(i<SIZE-1 && j>1)
 tab[i][j] = bl_return_bs_gch(tab[i+1][j-1],i,j); // fonction de la case bas gauche 
 
 if(i<SIZE-1)
 tab[i][j] = bl_return_bs_ct(tab[i+1][j],i,j);   // fonction de la case bas centre 
 
 if(i<SIZE-1 && j<SIZE-1)
 tab[i][j] = bl_return_bs_drt(tab[i+1][j+1],i,j);   // fonction de la case bas droite 
 
 
 //remplace les case de possibiliee par une case vide
 for(i=1;i<SIZE;i++)
 {
  for(j=1;j<SIZE;j++)
  {
   
   if(tab[i][j]==X)
   {		    
    tab[i][j]= ab ;
   }
   
  }
 }
}
/*--------------------------------------------------------------------------------------------------------------------------------------------*/
														/*FONCTION SECONDAIRE DE RETOURNEMENT DES PIONS B*/
int  bl_return_ht_gch(int  case_b,int col,int lig)	  //rentre la case au-dessus  , la ligne de la case et la colonne de la case 
{
 int i;
 int j;
 int  test;  // variable verifiant le nombre de pion qu'il fat retourner
 int  case_tmp = bl;  //variable static permettant de retourner la case clicke en un pion Blanc
 
 i=col; //sauvegarde les coordonnees pour permettre d'effectuer une recherche sans les perdre 
 j=lig;
 
 if(case_b==nr)		// si la case au-dessus est noir on verifie la case encore au-dessus jusqu'a que celle-ci soit blanche ou vide 
 {
  
  if(i>1 && j>1)
  {
   
   do
   {
    test=tab[i-1][j-1];
    i=i-1;
    j=j-1;
   }
   while(test==nr && i>1 && j>1);
  					   
   if(test==bl)		   // si elle est blanche il retourne toute la ligne en reprenant les coordonnees de debut
   {
    do
    {
     case_tmp=tab[col-1][lig-1];
     tab[col-1][lig-1]=bl;
     col=col-1;
     lig=lig-1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
  }
 }
return case_tmp;
}

/*--------------------------------------------------------------------------------------------------------------------------------------------*/
  //MEME PRINCIPE POUR LES FONCTIONS SUIVANTES 


int  bl_return_ht_ct(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test; 
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  
  if(i>1)
  {
   do
   {
    test=tab[i-1][j];
    i=i-1;
   }
   while(test==nr && i>1);
   
   if(test==bl)
   {
    do
    {
     case_tmp=tab[col-1][lig];
     tab[col-1][lig]=bl;
     col=col-1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
  
  }

 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_ht_drt(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;

 if(case_b==nr)
 {
  
  if(i>1 && j<SIZE-1)
  {
   do
   { 
    test=tab[i-1][j+1];
    i=i-1;
    j=j+1;
   }
   while(test==nr && i>1 && j<SIZE-1);
   
   if(test==bl)
   {
    do
    {
     case_tmp=tab[col-1][lig+1];
     tab[col-1][lig+1]=bl;
     col=col-1;
     lig=lig+1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
  
  }
 
 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_ml_gch(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  
  if(j>1)
  {
   do
   {
    test=tab[i][j-1];
    j=j-1;
   }
   while(test==nr && j>1);
   
   if(test==bl)
   {
    do
    {
     case_tmp=tab[col][lig-1];
     tab[col][lig-1]=bl;
     lig=lig-1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
   
  }
 
 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_ml_drt(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  if(i<SIZE-1)
  {
   do
   {
    test=tab[i][j+1];
    j=j+1;
   }
   while(test==nr && j<SIZE-1);
  
   if(test==bl)
   {
    do
    {
     case_tmp=tab[col][lig+1];
     tab[col][lig+1]=bl;
     lig=lig+1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
  
  }
 
 }
return case_tmp;
}



/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_bs_gch(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  
  if(i<SIZE-1 && j>1)
  {
   do
   {
    test=tab[i+1][j-1];
    i=i+1;
    j=j-1;
   }
   while(test==nr && i<SIZE-1 && j>1);
  
   if(test==bl)
   {
    do
    {
     case_tmp=tab[col+1][lig-1];
     tab[col+1][lig-1]=bl;
     col=col+1;
     lig=lig-1;
    }
    while(case_tmp==nr);
    case_b=bl;
   }
  
  }
 
 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_bs_ct(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  
  if(i<SIZE-1)
   {
	do
    {
     test=tab[i+1][j];
     i=i+1;
    }
    while(test==nr && i<SIZE-1);
    
	if(test==bl)
    {
     do
     {
      case_tmp=tab[col+1][lig];
      tab[col+1][lig]=bl;
      col=col+1;
     }
     while(case_tmp==nr);
     case_b=bl;
    }
  
   }
  
 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/


int  bl_return_bs_drt(int  case_b,int col,int lig)
{
 int i;
 int j;
 int  test;
 int  case_tmp=bl;
 i=col;
 j=lig;
 
 if(case_b==nr)
 {
  
   if(i<SIZE-1 && j<SIZE-1)
   {
	do
    {
     test=tab[i+1][j+1];
     i=i+1;
     j=j+1;
    }
    while(test==nr && i<SIZE-1 && j<SIZE-1);
    
	if(test==bl)
    {
     do
     {
      case_tmp=tab[col+1][lig+1];
      tab[col+1][lig+1]=bl;
      col=col+1;
      lig=lig+1;
     }
     while(case_tmp==nr);
     case_b=bl;
    }
	
   }
  
 }
return case_tmp;
}


/*--------------------------------------------------------------------------------------------------------------------------------------------*/
